
# Import delle librerie

#import for Numpy
import numpy as np

#import for Plotly
import plotly.express as px
import plotly.graph_objects as go

#import for Pandas
import pandas as pd

from datetime import datetime


df_earthQuake = pd.read_csv("data/EarthQuake/Earthquakes historical data from 1800 to 2021.csv")
df_toMerge1 = pd.read_csv("data/EarthQuake/earthquakes_secondCSV.csv")
df_toMerge2 = pd.read_csv("data/EarthQuake/Worldwide-Earthquake-database.csv")


def add_date_col(df_passed):
    main_cols = ['Year', 'Mo', 'Dy']
    add_cols = ['Hr', 'Mn', 'Sec']

    df = df_passed.dropna(subset=main_cols).copy()

    for col in main_cols:
        df[col] = df[col].astype(int).astype(str)

    df[main_cols[-2:]] = df[main_cols[-2:]].apply(lambda col: col.apply(lambda x: str(x).zfill(2)))

    df['Date'] = df[main_cols].agg('-'.join, axis=1)
    df['Date'] = pd.to_datetime(df['Date'], format='%Y-%m-%d', errors='coerce')
    df = df[['Date'] + [col for col in df.columns if col != 'Date']]

    valid_time = df[add_cols].notna().any(axis=1)

    for col in add_cols:
        df[col] = df[col].apply(lambda x: str(int(round(x))) if pd.notna(x) else '00').str.zfill(2)

    time_delta_str = df.loc[valid_time, add_cols].agg(':'.join, axis=1)
    time_delta = pd.to_timedelta(time_delta_str, errors='coerce')

    df.loc[valid_time, 'Date'] += time_delta
    df.dropna(subset=['Date'], inplace=True)
    df.drop(main_cols+add_cols, axis=1, inplace=True)
    return df


def clean_dataset(df):
    df.drop('I_D', axis=1, inplace=True)
    df.columns = [col.replace('_', ' ').title() for col in df.columns]
    df.columns = [col.title() for col in df.columns]
    df.rename(columns={
        'Month':'Mo', 'Day':'Dy', 'Hour':'Hr', 'Minute':'Mn', 'Second':'Sec', 'Focal Depth':'Focal Depth (km)',
        'Total Deaths Description':'Total Death Description', 'Deaths Description':'Death Description',
        'Total Damage Millions Dollars':'Total Damage ($Mil)', 'Damage Millions Dollars':'Damage ($Mil)',
        'Flag Tsunami':'Tsu', 'Eq Primary':'Mag', 'Intensity':'MMI Int'
    }, inplace=True)
    col_to_convert = ['Sec','Longitude', 'Latitude']
    df[col_to_convert] = df[col_to_convert].apply(pd.to_numeric, errors='coerce')

    df['Tsu'] = df['Tsu'].replace({'Yes':1, 'No':0}).astype(float)
    return df


df_toMerge2 = clean_dataset(df_toMerge2)

df_cleaned1 = add_date_col(df_earthQuake)
df_cleaned2 = add_date_col(df_toMerge1)
df_cleaned3 = add_date_col(df_toMerge2)


dataset_combinato = pd.concat([df_cleaned1, df_cleaned2], ignore_index=True).drop_duplicates(subset=['Date','Longitude','Latitude'])

df3_columns = ['Date', 'Longitude', 'Latitude', 'Eq Mag Ms', 'Eq Mag Unk', 'Eq Mag Mw', 'Eq Mag Mb', 'Country', 'Eq Mag Mfa', 'Region Code', 'State']

df_merged = pd.merge(dataset_combinato,
                     df_cleaned3[df3_columns],
                     left_on=['Date', 'Longitude', 'Latitude'],
                     right_on=['Date', 'Longitude', 'Latitude'],
                     how='left')

df_merged = pd.concat([df_merged, df_cleaned3], ignore_index=True).drop_duplicates(subset=['Date','Longitude','Latitude'])
df_merged = df_merged.sort_values(by='Date')
df_merged = df_merged.reset_index(drop=True)
df_merged = df_merged.dropna(subset=['Mag'])


df_merged.dtypes

Date                                  datetime64[ns]
Tsu                                          float64
Vol                                          float64
Location Name                                 object
Latitude                                     float64
Longitude                                    float64
Focal Depth (km)                             float64
Mag                                          float64
MMI Int                                      float64
Deaths                                       float64
Death Description                            float64
Missing                                      float64
Missing Description                          float64
Injuries                                     float64
Injuries Description                         float64
Damage ($Mil)                                float64
Damage Description                           float64
Houses Destroyed                             float64
Houses Destroyed Description                 float64
Houses Damaged                               float64
Houses Damaged Description                   float64
Total Deaths                                 float64
Total Death Description                      float64
Total Missing                                float64
Total Missing Description                    float64
Total Injuries                               float64
Total Injuries Description                   float64
Total Damage ($Mil)                          float64
Total Damage Description                     float64
Total Houses Destroyed                       float64
Total Houses Destroyed Description           float64
Total Houses Damaged                         float64
Total Houses Damaged Description             float64
Eq Mag Ms                                    float64
Eq Mag Unk                                   float64
Eq Mag Mw                                    float64
Eq Mag Mb                                    float64
Country                                       object
Eq Mag Mfa                                   float64
Region Code                                  float64
State                                         object
Eq Mag Ml                                    float64
dtype: object


df_merged


# Crea un grafico a dispersione con Plotly Express
fig = px.scatter(df_merged, x='Date', y=df_merged.index, 
                 title='Distribuzione Temporale degli Eventi Sismici',
                 labels={'index': 'Somma del numero di Eventi', 'Date': 'Data'})
fig.update_traces(marker=dict(size=5, opacity=0.5))
fig.update_layout(
    xaxis=dict(showline=True, linewidth=2, linecolor='black'),
    yaxis=dict(showline=True, linewidth=2, linecolor='black'),
    showlegend=False, height=600, width=1000)
# Mostra il grafico
fig.show()


df_merged['Year'] = pd.to_datetime(df_merged['Date']).dt.year
df_grouped = df_merged.groupby('Year').size().reset_index(name='Earthquakes')

# Crea il grafico con Plotly Express
fig = px.bar(df_grouped, x='Year', y='Earthquakes', labels={'Earthquakes': 'Numero di Terremoti'})
fig.update_layout(
    title='Distribuzione del numero di Terremoti per Anno', 
    xaxis_title='Anno', 
    yaxis_title='Numero di Terremoti',
    height=600, width=1000)

# Mostra il grafico
fig.show()


earthquake_data = pd.DataFrame({
    'Deaths': df_merged['Deaths'],
    'Year': df_merged['Date'].dt.year
})

# Group by year and sum the deaths for each year
deaths_per_year = earthquake_data.groupby('Year')['Deaths'].sum().reset_index()

# Calculate the average number of deaths per year
average_deaths_per_year = deaths_per_year['Deaths'].mean()

# Create a line plot using plotly.express
fig = px.line(deaths_per_year, x='Year', y='Deaths',
              title='Numero di morti a causa di terremoti ogni anno',
              labels={'Deaths': 'Numero di morti', 'Year': 'Anno'},
              template='plotly')

# Add a horizontal line for the average
fig.add_shape(type='line',
              x0=deaths_per_year['Year'].min(),
              x1=deaths_per_year['Year'].max(),
              y0=average_deaths_per_year,
              y1=average_deaths_per_year,
              line=dict(color='red', dash='dash')
              )

fig.add_annotation(
    x=deaths_per_year['Year'].min()+50,
    y=average_deaths_per_year-10,
    text=f'In media: {average_deaths_per_year:.2f} morti all\'anno',
    font=dict(size=14),
    showarrow=True,
    arrowhead=2,
    ax=50,
    ay=-120
)

fig.update_layout(
    xaxis=dict(showline=True, linewidth=2, linecolor='black'),
    yaxis=dict(showline=True, linewidth=2, linecolor='black'),
    showlegend=False, height=700, width=1100
)

fig.update_yaxes(range=[0,deaths_per_year['Deaths'].max()])

# Show the graph
fig.show()


df = df_merged.dropna(subset=['Latitude', 'Longitude', 'Mag'], inplace=False)
fig = px.scatter_geo(df, lat='Latitude', lon='Longitude',
                     title='Distribuzione Geografica degli Eventi Sismici',
                     labels={'Latitude': 'Latitudine', 'Longitude': 'Longitudine', 'Mag':'Magnitudine'},
                     hover_name='Location Name',
                     color_continuous_scale=px.colors.sequential.Reds,
                     projection='natural earth', 
                     color='Mag',  
                     opacity=0.7)  

fig.update_layout(geo=dict(projection_scale=1, center=dict(lat=0, lon=0)))
fig.update_layout(height=600, width=1000)
fig.show()


lat_min, lat_max = df_merged['Latitude'].min(), df_merged['Latitude'].max()
lon_min, lon_max = df_merged['Longitude'].min(), df_merged['Longitude'].max()
center_lat = (lat_min + lat_max) / 2
center_lon = (lon_min + lon_max) / 2

fig = px.density_mapbox(df_merged, lat='Latitude', lon='Longitude',
                        title='Heatmap della Distribuzione Geografica degli Eventi Sismici',
                        mapbox_style='carto-positron',
                        color_continuous_scale=px.colors.sequential.Reds,
                        opacity=0.7, radius=3, zoom=0.9,
                        center=dict(lat=center_lat+25, lon=center_lon+25))

fig.update_layout(
    margin=dict(l=10, r=10, b=10, t=60),
    height=600,
    width=1000,
    coloraxis_colorbar=dict(title='Densità')
)
fig.show()


df_merged['Affected Countries'] = df_merged['Location Name'].str.split(':').str[0]


geo_df = df_merged.dropna(subset=['Latitude', 'Longitude', 'Mag'], inplace=False)
color_scale_limits = [geo_df['Mag'].min(),geo_df['Mag'].max()]
geo_df = geo_df[geo_df['Date'].dt.year >= geo_df['Date'].max().year-50]

fig_map = px.scatter_geo(geo_df,
                         lat='Latitude',
                         lon='Longitude',
                         title='Distribuzione Geografica degli Eventi Sismici negli ultimi 50 anni',
                         labels={'Latitude': 'Latitudine', 'Longitude': 'Longitudine'},
                         hover_name='Location Name',
                         animation_frame=geo_df['Date'].dt.year,
                         color='Mag',
                         color_continuous_scale=px.colors.sequential.Reds,
                         range_color=color_scale_limits)

fig_map.update_geos(projection_type="natural earth")
fig_map.update_coloraxes(colorbar=dict(title='Magnitudine'))
fig_map.update_layout(width=1000, height=600)
fig_map.show()


countries_list = df_merged['Affected Countries'].str.split('; ', expand=True).stack().reset_index(level=1, drop=True).rename('AffCountry')
df_split = df_merged.drop('Affected Countries', axis=1).join(countries_list)

# Calcolo della media delle magnitudini per ogni paese
df_avg_mag = df_split.groupby('AffCountry')['Mag'].mean().reset_index()

# Creazione del grafico choropleth
fig = px.choropleth(df_avg_mag, 
                    locations='AffCountry',
                    locationmode='country names',
                    color='Mag',
                    title='Magnitudine media per Paese',
                    color_continuous_scale=px.colors.sequential.Blues)

fig.update_coloraxes(colorbar=dict(title='Magnitudine Media'))
fig.update_layout(height=600, width=1000)
fig.show()


conteggio_paesi = df_merged['Affected Countries'].value_counts().reset_index()
conteggio_paesi.columns = ['Paese', 'Numero Terremoti']

top_10_paesi = conteggio_paesi.head(10)['Paese'].tolist()

df_top_10 = df_merged[df_merged['Affected Countries'].isin(top_10_paesi)].copy()
df_top_10['Affected Countries'] = pd.Categorical(df_top_10['Affected Countries'], categories=top_10_paesi, ordered=True)
df_top_10 = df_top_10.sort_values(by='Affected Countries')

fig = px.box(df_top_10, x='Affected Countries', y='Mag', title='Box Plot delle Magnitudini dei 10 Paesi più colpiti',
             category_orders={'Affected Countries': top_10_paesi})
for i, row in conteggio_paesi.iterrows():
    if row['Paese'] in top_10_paesi:
        fig.add_annotation(x=row['Paese'], y=df_top_10['Mag'].min()-1,
                           text=row["Numero Terremoti"],
                           showarrow=False, font=dict(size=13))
fig.update_yaxes(range=[df_top_10['Mag'].min()-1.5, len(top_10_paesi)])
fig.update_layout(yaxis_title="Magnitudine", xaxis_title="10 Paesi più colpiti", height=800, width=1100,
    xaxis=dict(showline=True, linewidth=2, linecolor='black'),
    yaxis=dict(showline=True, linewidth=2, linecolor='black'))
fig.show()


fig = px.density_heatmap(df_merged,
                         x=df_merged['Date'].dt.year,
                         y='Mag',
                         marginal_x='histogram',
                         marginal_y='histogram',
                         title='Heatmap Temporale delle Magnitudini',
                         nbinsx=90, nbinsy=20)
fig.update_layout(
    xaxis=dict(range=[1897, datetime.now().year], showline=True, linewidth=2, linecolor='black'),
    yaxis=dict(range=[3, 9], showline=True, linewidth=2, linecolor='black'),
    yaxis_title="Magnitude",
    xaxis_title="Anno",
    height=500, width=1000
)

fig.update_coloraxes(colorbar=dict(title='Numero di terremoti'))
fig.show()


mag_mean_without_both = df_merged['Mag'].mean()
mag_mean_with_tsunami = df_merged[df_merged['Tsu'].notnull()]['Mag'].mean()
mag_mean_with_volcano = df_merged[df_merged['Vol'].notnull()]['Mag'].mean()
mag_mean_with_both = df_merged[df_merged['Tsu'].notnull() & df_merged['Vol']]['Mag'].mean()

data = {'Tsunami': ['Without both', 'With Tsunami', 'With Volcano', 'With both'],
        'Average Magnitude': [mag_mean_without_both, mag_mean_with_tsunami, mag_mean_with_volcano, mag_mean_with_both]}
avg_mag_df = pd.DataFrame(data)
fig = px.bar(avg_mag_df, x='Tsunami', y='Average Magnitude',
             title='Magnitudine media dei terremoti che causano Tsunami o Eruzioni Vulcaniche',
             labels={'Average Magnitude': 'Magnitudine Media', 'Tsunami':'Codizioni Tsunami ed Eruzioni Vulcaniche'})

fig.update_layout(
    height=700, width=1000,
    xaxis=dict(showline=True, linewidth=2, linecolor='black'),
    yaxis=dict(showline=True, linewidth=2, linecolor='black'),
)

fig.show()


# Crea una nuova colonna 'Evento' basata sui valori in 'tsu' e 'vul'
df_pie = df_merged

df_pie['Event'] = df_pie.apply(lambda row: 'Entrambi' if (pd.notna(row['Tsu'])) and (pd.notna(row['Vol']))
else ('Tsunami' if pd.notna(row['Tsu'])
      else ('Eruzione vulcanica' if pd.notna(row['Vol']) > 0
            else 'Nessun evento')), axis=1)
# Creazione del grafico a torta
fig = px.pie(df_pie, names='Event', title='Distribuzione di Eventi Sismici che hanno causato Tsunami o Eruzioni Vulcaniche')
fig.update_traces(textinfo='percent', insidetextorientation='radial', textfont_size=16)
fig.update_layout(height=500, width=800, legend=dict(font=dict(size=16)))
fig.show()


fig = px.density_heatmap(df_merged, y='Focal Depth (km)', x='Mag',
                         title='Heatmap Relazione tra Profondità e Magnitudine',
                         labels={'Focal Depth (km)': 'Profondità', 'Mag': 'Magnitudine'},
                         color_continuous_scale=px.colors.sequential.Reds,
                         nbinsx=100, nbinsy=200)
fig.update_yaxes(range=[0,100])
fig.update_xaxes(range=[3.8,8.5])
fig.update_layout(
    xaxis=dict(showline=True, linewidth=2, linecolor='black'),
    yaxis=dict(showline=True, linewidth=2, linecolor='black'),
    width=1000, height=500)
fig.show()


filtered_data = df_merged.dropna(subset=['MMI Int'], inplace=False)
grouped_data = filtered_data.groupby('Mag')['MMI Int'].mean().reset_index()

x = grouped_data['Mag']
y = grouped_data['MMI Int']
coefficients = np.polyfit(x, y, 1)
slope, intercept = coefficients

fig = px.bar(grouped_data, x='Mag', y='MMI Int', title='Relazione tra intensità MMI e Magnitudine')

x_values = np.linspace(x.min(), x.max(), 100)
y_values = slope * x_values + intercept

fig.add_trace(go.Scatter(
    x=x_values,
    y=y_values,
    mode='lines',
    name='Regression Line',
    line=dict(color='red', dash='dot')
))
fig.update_layout(xaxis_title='Magnitudine', yaxis_title='Intensità MMI media', width=1000, height=500,
                  xaxis=dict(showline=True, linewidth=2, linecolor='black'),
                  yaxis=dict(showline=True, linewidth=2, linecolor='black'))
fig.update_xaxes(range=[grouped_data['Mag'].min()-.1, grouped_data['Mag'].max()+.1])
fig.show()


# Filtra righe con dati validi su Magnitude e Location Name
filtered_df = df_merged.dropna(subset=['Mag', 'Location Name'], inplace=False)

# Ordina il DataFrame in base alla magnitudo in ordine decrescente
top_10_df = filtered_df.sort_values(by='Mag', ascending=False).head(10)

# Crea il grafico a barre
fig = px.bar(top_10_df, x='Location Name', y='Mag',
             title='10 Terremoti più Potenti per Località',
             labels={'Mag': 'Magnitudine', 'Location Name': 'Località'})
# aggiunta della scala logaritmica sull'asse y per gestire le differenze di scala
fig.update_layout(yaxis_type='log', width=1100, height=800,
                  xaxis=dict(showline=True, linewidth=2, linecolor='black'),
                  yaxis=dict(showline=True, linewidth=2, linecolor='black'))

# Mostra il grafico
fig.show()


# Select relevant columns
earthquake_data = df_merged[['Affected Countries', 'Deaths']]

# Group by location and sum the deaths for each location
grouped_data = earthquake_data.groupby('Affected Countries')['Deaths'].sum().reset_index()

# Sort the data by the number of deaths in descending order and take the top 25
top_25_deadliest = grouped_data.sort_values(by='Deaths', ascending=False).head(25)

# Create the horizontal bar chart using plotly.express
fig = px.bar(top_25_deadliest,
             y='Affected Countries',
             x='Deaths',
             orientation='h',
             title='I 25 terremoti più letali per paese colpito',
             labels={'Deaths': 'Numero di Morti', 'Affected Countries': 'Paese Colpito'},
             template='plotly',
             opacity=0.7)

fig.update_layout(width=1000, height=700,
                  xaxis=dict(showline=True, linewidth=2, linecolor='black'),
                  yaxis=dict(showline=True, linewidth=2, linecolor='black'))
# Show the graph
fig.show()


# Seleziona le colonne necessarie per il grafico
data_for_plot = df_merged[['Mag', 'Focal Depth (km)']]

# Rimuovi righe con valori mancanti in una delle colonne
data_for_plot = data_for_plot.dropna()

# Crea il grafico con plotly.express invertendo gli assi
fig = px.scatter(data_for_plot, x='Focal Depth (km)', y='Mag',
                 title='Relazione tra Profondità Focale e Magnitudine',
                 labels={'Focal Depth (km)': 'Profondità Focale (km)', 'Mag': 'Magnitudine'})

# Imposta gli estremi e gli step degli assi
fig.update_yaxes(range=[data_for_plot['Mag'].min()-.2, data_for_plot['Mag'].max()+.2], dtick=1)
fig.update_xaxes(range=[-1, data_for_plot['Focal Depth (km)'].max()+10], dtick=100)
fig.update_layout(height=700, width=1000,
                 xaxis=dict(showline=True, linewidth=2, linecolor='black'),
                 yaxis=dict(showline=True, linewidth=2, linecolor='black')
)
# Mostra il grafico
fig.show()


earthquake_data = pd.DataFrame({
    'Total Damage ($Mil)': df_merged['Total Damage ($Mil)'],
    'Year': df_merged['Date'].dt.year
})

# Group by year and sum the total damages for each year
damages_per_year = earthquake_data.groupby('Year')['Total Damage ($Mil)'].sum().reset_index()

# Create a line plot using plotly.express
fig = px.line(damages_per_year, x='Year', y='Total Damage ($Mil)',
              title='Danni Totali dei terremoti ogni anno',
              labels={'Total Damage ($Mil)': 'Danni Totali (Milioni di $)', 'Year': 'Anno'},
              template='plotly')

fig.update_xaxes(range=[1970, damages_per_year['Year'].max()])
fig.update_yaxes(range=[0, damages_per_year['Total Damage ($Mil)'].max()])

fig.update_layout(height=700, width=1000,
                  xaxis=dict(showline=True, linewidth=2, linecolor='black'),
                  yaxis=dict(showline=True, linewidth=2, linecolor='black')
                  )

# Show the graph
fig.show()

	Date	Tsu	Vol	Location Name	Latitude	Longitude	Focal Depth (km)	Mag	MMI Int	Deaths	...	Total Houses Damaged Description	Eq Mag Ms	Eq Mag Unk	Eq Mag Mw	Eq Mag Mb	Country	Eq Mag Mfa	Region Code	State	Eq Mag Ml
0	1677-11-04 00:00:00	322.0	NaN	JAPAN: OFF SE. BOSO PENINSULA	35.000	141.500	NaN	7.4	NaN	NaN	...	NaN	7.4	NaN	NaN	NaN	JAPAN	NaN	30.0	NaN	NaN
5	1678-06-18 01:45:00	325.0	NaN	PERU: LIMA,SALINAS-HUAURA,LIMA,CALLAO,CHANCAY	-9.000	-79.000	40.0	8.4	9.0	NaN	...	NaN	8.4	NaN	NaN	NaN	PERU	NaN	160.0	NaN	NaN
6	1678-10-02 00:00:00	NaN	NaN	JAPAN: SANRIKU,RIKUCHU	38.600	142.000	NaN	7.4	NaN	1.0	...	NaN	NaN	7.4	NaN	NaN	JAPAN	NaN	30.0	NaN	NaN
7	1679-06-04 00:00:00	NaN	NaN	TURKEY; ARMENIA: DVINA	40.100	44.700	15.0	5.9	NaN	7600.0	...	NaN	NaN	5.9	NaN	NaN	TURKEY	NaN	140.0	NaN	NaN
8	1679-09-02 00:00:00	NaN	NaN	CHINA: HEBEI PROVINCE	40.000	117.000	NaN	8.0	11.0	13162.0	...	NaN	8.0	NaN	NaN	NaN	CHINA	NaN	30.0	NaN	NaN
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
5467	2023-01-28 18:14:45	NaN	NaN	IRAN: KHVOY (KHOY)	38.424	44.909	16.0	5.9	8.0	3.0	...	4.0	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN
5468	2023-02-06 01:17:35	5873.0	NaN	TURKEY; SYRIA	37.166	37.042	17.0	7.8	9.0	48224.0	...	4.0	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN
5469	2023-02-06 10:24:49	NaN	NaN	TURKEY; SYRIA	38.024	37.203	10.0	7.5	9.0	NaN	...	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN
5470	2023-02-09 06:28:00	NaN	NaN	INDONESIA: NEW GUINEA: IRIAN JAYA: JAYAPURA	-2.635	140.557	22.0	5.1	8.0	4.0	...	1.0	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN
5471	2023-02-20 17:04:29	NaN	NaN	TURKEY; SYRIA	36.109	36.017	16.0	6.3	9.0	6.0	...	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN

Dataset Earthquakes historical data from 1800 to 2021¶

Set-Up generale:¶

Aggiunta della colonna Date¶

Distribuzione temporale degli eventi sismici¶

Numero annuo di Morti causa terremoto¶

Distribuzione geografica degli eventi sismici¶

Magnitudine media¶

Osservazione delle dieci magnitudini nei paesi più colpiti¶

Magnitudini degli eventi sismici¶

Analisi catastrofi naturali scaturite da terremoti¶

Analisi profondità e magnitudine:¶

Intensità scala Mercalli e magnitudo¶

Scala Mercalli:¶

I dieci terremoti più¶

Terremoti letali¶

Analisi relazione tra profondità focale e magnitudine¶

Danni totali dei terremoti¶